Aminet 46/Aminet 46 (2001)(GTI - Schatztruhe)[!][Dec 2001].iso/Aminet/text/edit/edt10src.lha/txt/ERexx.mod

Text File | 1995-04-08 | 21KB | 903 lines

(*
  .name       ERexx
  .task       ARexx-Interface of Edt
  .release    1.0
  .language   Oberon-2
  .translator Amiga Oberon 3.11
  .system     AmigaOS 2.04/2.1/3.0
  .author     Joachim Barheine
  .address    Hochgrevestraße 3, D-38640 Goslar
  .copyright  (c) 1994 by Joachim Barheine
*)

(* .info: 29/09/94, 13:38:24, version 48 *)

MODULE ERexx;

IMPORT
  SYS:= SYSTEM,

  ASCII,
  AVL:= UntracedAVL,
  Dos,
  Err:= ErrCodes,
  Exec,
  GUI,
  IO:= IOServer,
  K:= Kernel,
  Req:= ERequests,
  Rexx,
  Rx:= RexxSysLib,
  S:= Strings,
  Str:= StrPool;

CONST
  true* = "1";
  false* = "0";

  (* commands: *)
  activateWindow*  = 0;
  beginMacro*      = 1;
  beginMark*       = 2;
  bottom*          = 3;
  busy*            = 4;
  busyDone*        = 5;
  closeAllFolds* = 6;
  closeFold*     = 7;
  compile*         = 8;
  copy*            = 9;
  cursorOff*       = 10;
  cursorOn*        = 11;
  cut*             = 12;
  delBack*         = 13;
  delete*          = 14;
  delLines*        = 15;
  displayBeep*     = 16;
  displayOff*      = 17;
  displayOn*       = 18;
  displayPrefs*    = 19;
  down*            = 20;
  editPrefs*       = 21;
  endMacro*        = 22;
  endMark*         = 23;
  enterRexx*       = 24;
  erase*           = 25;
  execRexx*        = 26;
  execMacro*       = 27;
  execute*         = 28;
  find*            = 29;
  first*           = 30;
  firstError*   = 31;
  firstText*       = 32;
  firstWindow*     = 33;
  forceAutosave*   = 34;
  freeMacro*       = 35;
  get*             = 36;
  getASCII*        = 37;
  getBookmark*     = 38;
  gotoBookmark*    = 39;
  gotoError*    = 40;
  gotoLine*        = 41;
  information*     = 42;
  insASCII*        = 43;
  insert*          = 44;
  insertFile*      = 45;
  item*            = 46;
  last*            = 47;
  lastChange*      = 48;
  lastText*        = 49;
  lastWindow*      = 50;
  left*            = 51;
  link*            = 52;
  linkChanges*     = 53;
  linkChangesDone* = 54;
  loadErrors*   = 55;
  make*            = 56;
  matchBracket*    = 57;
  menu*            = 58;
  move*            = 59;
  new*             = 60;
  newFold*       = 61;
  newWindow*       = 62;
  nextError*    = 63;
  nextText*        = 64;
  nextWindow*      = 65;
  open*            = 66;
  openAllFolds*  = 67;
  openFold*      = 68;
  pageDown*        = 69;
  pageUp*          = 70;
  paste*           = 71;
  prevError*    = 72;
  prevText*        = 73;
  prevWindow*      = 74;
  print*           = 75;
  printClip*       = 76;
  quit*            = 77;
  read*            = 78;
  redo*            = 79;
  redraw*          = 80;
  repeatRexx*      = 81;
  replace*         = 82;
  reqAction*       = 83;
  reqNumber*       = 84;
  reqOptions*      = 85;
  reqChoice*       = 86;
  reqString*       = 87;
  resolveAllFolds* = 88;
  resolveFold*  = 89;
  right*           = 90;
  save*            = 91;
  saveAs*          = 92;
  saveClip*        = 93;
  saveMacro*       = 94;
  saveSettings*    = 95;
  saveTemp*        = 96;
  screenToBack*    = 97;
  screenToFront*   = 98;
  scrollDX*        = 99;
  scrollDY*        = 100;
  selectText*      = 101;
  selectWindow*    = 102;
  set*             = 103;
  setBookmark*     = 104;
  setKey*          = 105;
  setWindowBox*    = 106;
  shiftClip*       = 107;
  subItem*         = 108;
  title*           = 109;
  toLower*         = 110;
  top*             = 111;
  toUpper*         = 112;
  undo*            = 113;
  unMark*          = 114;
  up*              = 115;
  windowToBack*    = 116;
  windowToFront*   = 117;
  wordBegin*       = 118;
  wordEnd*         = 119;
  wordLeft*        = 120;
  wordRight*       = 121;

  (* variables: *)
  vAutoIndent*   = 0;
  vChanges*      = 1;
  vCleanLines*   = 2;
  vColumn*       = 3;
  vFilename*     = 4;
  vFindStr*      = 5;
  vIcons*        = 6;
  vInsert*       = 7;
  vLength*       = 8;
  vLine*         = 9;
  vLineBegin*    = 10;
  vLineEnd*      = 11;
  vLineLen*      = 12;
  vMargin*       = 13;
  vMark*         = 14;
  vMarkBegin*    = 15;
  vMarkEnd*      = 16;
  vName*         = 17;
  vPath*         = 18;
  vPosition*     = 19;
  vRecording*    = 20;
  vReplaceStr*   = 21;
  vScreenHeight* = 22;
  vScreenWidth*  = 23;
  vSize*         = 24;
  vTextID*       = 25;
  vTexts*        = 26;
  vWindowCols*   = 27;
  vWindowID*     = 28;
  vWindowLeft*   = 29;
  vWindowLines*  = 30;
  vWindowTop*    = 31;
  vWindowHeight* = 32;
  vWindows*      = 33;
  vWindowWidth*  = 34;
  vWordWrap*     = 35;

  (* keys: *)
  kAlt*       = 0;
  kAmiga*     = 1;
  kBackspace* = 2;
  kCtrl*      = 3;
  kDel*       = 4;
  kDown*      = 5;
  kEnter*     = 6;
  kEsc*       = 7;
  kF1*        = 8;
  kF2*        = 9;
  kF3*        = 10;
  kF4*        = 11;
  kF5*        = 12;
  kF6*        = 13;
  kF7*        = 14;
  kF8*        = 15;
  kF9*        = 16;
  kF10*       = 17;
  kHelp*      = 18;
  kLeft*      = 19;
  kNumPad*    = 20;
  kReturn*    = 21;
  kRight*     = 22;
  kShift*     = 23;
  kSpace*     = 24;
  kTab*       = 25;
  kUp*        = 26;

  (* quick commands: *)
  upStr*      = "UP";
  downStr*    = "DOWN";
  rightStr*   = "RIGHT";
  leftStr*    = "LEFT";
  moveR1Str*  = "MOVE 1";
  moveL1Str*  = "MOVE (-1)";
  undoStr*    = "UNDO";
  redoStr*    = "REDO";
  deleteStr*  = "DELETE";
  delBackStr* = "DELBACK";

TYPE
  Ident* = AVL.String;

  Node= UNTRACED POINTER TO NodeDesc;
  NodeDesc= RECORD (AVL.SNode)
    id: INTEGER;
  END;

VAR
  oldPos, pos: LONGINT;                   (* (prev.) parse position *)
  cmdLine: Exec.LSTRPTR;
  cmdStr: Ident;                  (* command name *)
  cmds, keys, vars: AVL.SRoot;
  msgCnt: INTEGER;    (* outstanding messages *)
  quoted- : BOOLEAN;              (* token quoted? *)
  rMsg: Rexx.RexxMsgPtr;
  stdioDesc- : ARRAY 256 OF CHAR;
  stdio- : Dos.FileHandlePtr;
  missingArgs: BOOLEAN;

(* -- misc -- *)
PROCEDURE ErrorMsg* (str: ARRAY OF CHAR);

(* $CopyArrays- *)

BEGIN
  GUI.Flash;
  IF Dos.Write(stdio, cmdStr, S.Length(cmdStr)) = 0 THEN END;
  IF Dos.Write(stdio, ": ", 2) = 0 THEN END;
  IF Dos.Write(stdio, str, S.Length(str)) = 0 THEN END;
  IF Dos.Write(stdio, ":\n» ", 4) = 0 THEN END;
  IF Dos.Write(stdio, cmdLine^, S.Length(cmdLine^)) = 0 THEN END;
  IF Dos.Write(stdio, "\n\n", 2) = 0 THEN END;
END ErrorMsg;

(* -- string pool -- *)

PROCEDURE New(VAR root: AVL.SRoot; name: ARRAY OF CHAR; id: INTEGER);
VAR
  n: Node;

(* $CopyArrays- *)

BEGIN
  NEW(n);
  COPY(name, n.name);
  n.id:= id;
  IF AVL.SAdd(root, n) THEN END;
END New;

PROCEDURE DefineCmd(name: ARRAY OF CHAR; id: INTEGER);

(* $CopyArrays- *)

BEGIN
  New(cmds, name, id);
END DefineCmd;

PROCEDURE DefineVar(name: ARRAY OF CHAR; id: INTEGER);

(* $CopyArrays- *)

BEGIN
  New(vars, name, id);
END DefineVar;

PROCEDURE DefineKey(name: ARRAY OF CHAR; id: INTEGER);

(* $CopyArrays- *)

BEGIN
  New(keys, name, id);
END DefineKey;

PROCEDURE GetID(VAR id: INTEGER; VAR root: AVL.SRoot; name: Ident): BOOLEAN;

VAR
  n: AVL.NodePtr;

(* $CopyArrays- *)

BEGIN
  n:= AVL.SFind(root, name);
  IF n # NIL THEN
    id:= n(Node).id;
    RETURN TRUE;
  ELSE
    RETURN FALSE;
  END;
END GetID;

(* -- parsing -- *)

PROCEDURE SkipBlanks;

BEGIN
  WHILE cmdLine[pos] = " " DO INC(pos) END;
END SkipBlanks;

(* get number at argument string position 'pos'; result: val is valid *)
PROCEDURE GetNum* (VAR n: LONGINT): BOOLEAN;

VAR
  e: SHORTINT;
  brackets: BOOLEAN;

  PROCEDURE Skip;

  BEGIN
    IF brackets & (cmdLine[pos] = ")") THEN INC(pos) END;
    SkipBlanks;
  END Skip;

BEGIN
  oldPos:= pos;
  brackets:= (cmdLine[pos] = "(");
  IF brackets THEN INC(pos) END;
  IF K.MatchIC(cmdLine^, pos, "-") THEN e:= -1 ELSE e:= 1 END;
  IF K.ReadInt(cmdLine^, pos, n) THEN
    n:= e * n;  (* set sign *)
    Skip;
    RETURN TRUE;
  ELSE
    Skip;
    RETURN FALSE;
  END;
END GetNum;

PROCEDURE GetNumDef* (VAR num: LONGINT; def: LONGINT);

BEGIN
  IF ~GetNum(num) THEN num:= def END;
END GetNumDef;

PROCEDURE GetNumErr* (VAR num: LONGINT): BOOLEAN;

BEGIN
  IF GetNum(num) THEN
    RETURN TRUE;
  ELSIF ~missingArgs THEN
    ErrorMsg(Str.missingArgs^);
    missingArgs:= TRUE;
    RETURN FALSE;
  END;
END GetNumErr;

(* get string at argument string position 'pos'; result: str not empty *)
PROCEDURE GetStr* (VAR str: ARRAY OF CHAR): BOOLEAN;

VAR
  i: INTEGER;
  qc: CHAR;

  PROCEDURE Get;

  BEGIN
    WHILE (i < LEN(str) - 1)  & (cmdLine[pos] # qc) & (cmdLine[pos] # ASCII.nul) DO
      str[i]:= cmdLine[pos];
      INC(i); INC(pos);
    END;
  END Get;

BEGIN
  oldPos:= pos;
  IF cmdLine[pos] # ASCII.nul THEN
    i:= 0;
    quoted:= (cmdLine[pos] = '"') OR (cmdLine[pos] = "'") OR (cmdLine[pos] = "`");
    IF quoted THEN
      qc:= cmdLine[pos]; INC(pos);
      Get;
      IF cmdLine[pos] = qc THEN INC(pos) ELSE GUI.Flash END;
    ELSE
      qc:= " ";
      Get;
    END;
    str[i]:= ASCII.nul;
    SkipBlanks;
    RETURN TRUE;
  ELSE
    RETURN FALSE;
  END;
END GetStr;

PROCEDURE GetStrDef* (VAR str: ARRAY OF CHAR; def: ARRAY OF CHAR);

(* $CopyArrays- *)

BEGIN
  IF ~GetStr(str) THEN COPY(def, str) END;
END GetStrDef;

PROCEDURE GetStrErr* (VAR str: ARRAY OF CHAR): BOOLEAN;

BEGIN
  IF GetStr(str) THEN
    RETURN TRUE;
  ELSIF ~missingArgs THEN
    ErrorMsg(Str.missingArgs^);
    missingArgs:= TRUE;
    RETURN FALSE;
  END;
END GetStrErr;

PROCEDURE GetStrLast* (VAR str: ARRAY OF CHAR): BOOLEAN;

VAR
  len: LONGINT;

BEGIN
  oldPos:= pos;
  len:= S.Length(cmdLine^) - pos;
  IF (cmdLine[pos] = "'") OR (cmdLine[pos] = '"') OR (cmdLine[pos] = "`") THEN
    INC(pos); DEC(len, 2);  (* do not copy brackets *)
  END;
  IF (len > 0) & (len < LEN(str)) THEN
    K.Copy(cmdLine^, pos, str, 0, len);
    str[len]:= ASCII.nul;
    RETURN TRUE;
  ELSE
    RETURN FALSE;
  END;
END GetStrLast;

PROCEDURE GetStrLastDef* (VAR str: ARRAY OF CHAR; def: ARRAY OF CHAR);

(* $CopyArrays- *)

BEGIN
  IF ~GetStrLast(str) THEN COPY(def, str) END;
END GetStrLastDef;

PROCEDURE GetStrLastErr* (VAR str: ARRAY OF CHAR): BOOLEAN;

BEGIN
  IF GetStrLast(str) THEN
    RETURN TRUE;
  ELSIF ~missingArgs THEN
    ErrorMsg(Str.missingArgs^);
    missingArgs:= TRUE;
    RETURN FALSE;
  END;
END GetStrLastErr;

PROCEDURE Match* (token: ARRAY OF CHAR): BOOLEAN;

(* $CopyArrays- *)

BEGIN
  oldPos:= pos;
  IF K.MatchIC(cmdLine^, pos, token) THEN
    SkipBlanks;
    RETURN TRUE;
  ELSE
    RETURN FALSE;
  END;
END Match;

(* reset index *)
PROCEDURE UnGet*;

BEGIN
  pos:= oldPos;
END UnGet;

PROCEDURE More* (): BOOLEAN;

BEGIN
  RETURN cmdLine[pos] # ASCII.nul;
END More;

PROCEDURE GetCmdID* (VAR id: INTEGER): BOOLEAN;

VAR
  i: INTEGER;

BEGIN
  missingArgs:= FALSE;
  SkipBlanks;
  IF cmdLine[pos] # ASCII.nul THEN
    i:= 0;
    WHILE (i < LEN(cmdStr) - 1) & (cmdLine[pos] # ASCII.nul) & (cmdLine[pos] # " ") DO
      cmdStr[i]:= CAP(cmdLine[pos]);
      INC(i); INC(pos);
    END;
    cmdStr[i]:= ASCII.nul;
    SkipBlanks;  (* get to first argument *)
    RETURN GetID(id, cmds, cmdStr);
  ELSE
    rMsg.result1:= K.rcIllegal;
    RETURN FALSE;
  END;
END GetCmdID;

PROCEDURE GetKeyID* (VAR id: INTEGER; name: Ident): BOOLEAN;

(* $CopyArrays- *)

BEGIN
  RETURN GetID(id, keys, name);
END GetKeyID;

PROCEDURE GetVarID* (VAR id: INTEGER): BOOLEAN;

VAR
  name: AVL.String;

(* $CopyArrays- *)

BEGIN
  IF GetStr(name) THEN
    S.Upper(name);
    RETURN GetID(id, vars, name);
  ELSE
    RETURN FALSE;
  END;
END GetVarID;

PROCEDURE GetVarIDErr* (VAR id: INTEGER): BOOLEAN;

BEGIN
  IF GetVarID(id) THEN
    RETURN TRUE;
  ELSIF ~missingArgs THEN
    ErrorMsg(Str.missingArgs^);
    missingArgs:= TRUE;
    RETURN FALSE;
  END;
END GetVarIDErr;

(* -- ARexx link -- *)

PROCEDURE SetResult* (str: ARRAY OF CHAR);

(* $CopyArrays- *)

BEGIN
  IF Rexx.rxfResult IN Rexx.ActionFlags(rMsg.action) THEN
    rMsg.result2:= Rx.CreateArgstring(str, S.Length(str));
  END;
END SetResult;

PROCEDURE SetBoolResult* (bool: BOOLEAN);

BEGIN
  IF bool THEN SetResult(true) ELSE SetResult(false) END;
END SetBoolResult;

PROCEDURE SetIntResult* (int: LONGINT);

VAR
  str: ARRAY 20 OF CHAR;

BEGIN
  K.IntToStr(str, int);
  SetResult(str);
END SetIntResult;

(* -- ARexx invocation -- *)

(* execute an ARexx command-file or -string; result: done? *)
PROCEDURE Execute* (cmdStr: ARRAY OF CHAR; cmdFile: BOOLEAN): BOOLEAN;

VAR
  cmd: Exec.LSTRPTR;
  rMsg: Rexx.RexxMsgPtr;
  rexx: Exec.MsgPortPtr;

(* $CopyArrays- *)

BEGIN
  rMsg:= Rx.CreateRexxMsg(IO.rexxPort, "edt", IO.rexxPortName);
  IF rMsg # NIL THEN
    IF stdio # NIL THEN rMsg.stdin:= stdio; rMsg.stdout:= stdio END;
    cmd:= Rx.CreateArgstring(cmdStr, S.Length(cmdStr));
    IF cmd # NIL THEN
      IF cmdFile THEN
        rMsg.action:= Rexx.rxComm;
      ELSE
        rMsg.action:= Rexx.rxComm + Rexx.rxString;
      END;
      rMsg.args[0]:= cmd;
      rMsg.node.node.name:= SYS.ADR(Rexx.rxsDir);
      Exec.Forbid;
      rexx:= Exec.FindPort(Rexx.rxsDir);
      IF rexx # NIL THEN
        Exec.PutMsg(rexx, rMsg);
        INC(msgCnt);
      END;
      Exec.Permit;
      IF rexx = NIL THEN
        Req.ReqMessage(NIL, Str.noRexxPort^, Str.cancel^);
      ELSE
        RETURN TRUE;
      END;
      Rx.DeleteArgstring(cmd);
    END;
    Rx.DeleteRexxMsg(rMsg);
  END;
  RETURN FALSE;
END Execute;

PROCEDURE GetMsg* (): BOOLEAN;

VAR
  m: Exec.MessagePtr;

BEGIN
  LOOP
    m:= Exec.GetMsg(IO.rexxPort);
    WHILE m = NIL DO
      IF msgCnt <= 0 THEN
        RETURN FALSE;
      ELSE
        Exec.WaitPort(IO.rexxPort);
      END;
      m:= Exec.GetMsg(IO.rexxPort)(Rexx.RexxMsg);  (* new trial *)
    END;
    rMsg:= m(Rexx.RexxMsg);
    IF (rMsg.result1 = 0) & (rMsg.result2 # NIL) THEN
      Rx.DeleteArgstring(rMsg.result2);
    END;
    IF rMsg.node.node.type # Exec.replyMsg THEN
      rMsg.result1:= 0;
      rMsg.result2:= 0;
      cmdLine:= rMsg.args[0];
      pos:= 0;
      RETURN TRUE;
    ELSE
      Rx.DeleteArgstring(rMsg.args[0]);
      Rx.DeleteRexxMsg(rMsg);
      DEC(msgCnt);
    END;
  END;
END GetMsg;

PROCEDURE ReplyMsg*;

BEGIN
  Exec.ReplyMsg(rMsg);
END ReplyMsg;

PROCEDURE OpenStdIO;

VAR
  sName: ARRAY 128 OF CHAR;
  a: ARRAY 1 OF LONGINT;

BEGIN
  COPY(IO.screenName, sName);
  a[0]:= SYS.ADR(sName);
  K.FormatString(stdioDesc, Str.edtConsole^, a);
  stdio:= Dos.Open(stdioDesc, Dos.oldFile);
  K.Assert(stdio # NIL, Err.eRexxNoStdIO);
END OpenStdIO;

BEGIN
  OpenStdIO;

  (* commands: *)
  AVL.SInit(cmds);
  DefineCmd("ACTIVATEWINDOW", activateWindow);
  DefineCmd("BEGINMACRO", beginMacro);
  DefineCmd("BEGINMARK", beginMark);
  DefineCmd("BOTTOM", bottom);
  DefineCmd("BUSY", busy);
  DefineCmd("BUSYDONE", busyDone);
  DefineCmd("CLOSEALLFOLDS", closeAllFolds);
  DefineCmd("CLOSEFOLD", closeFold);
  DefineCmd("COPY", copy);
  DefineCmd("CURSOROFF", cursorOff);
  DefineCmd("CURSORON", cursorOn);
  DefineCmd("CUT", cut);
  DefineCmd("DELBACK", delBack);
  DefineCmd("DELETE", delete);
  DefineCmd("DELLINES", delLines);
  DefineCmd("DISPLAYBEEP", displayBeep);
  DefineCmd("DISPLAYOFF", displayOff);
  DefineCmd("DISPLAYON", displayOn);
  DefineCmd("DISPLAYPREFS", displayPrefs);
  DefineCmd("DOWN", down);
  DefineCmd("EDITPREFS", editPrefs);
  DefineCmd("ENDMACRO", endMacro);
  DefineCmd("ENDMARK", endMark);
  DefineCmd("ENTERREXX", enterRexx);
  DefineCmd("ERASE", erase);
  DefineCmd("EXECMACRO", execMacro);
  DefineCmd("EXECREXX", execRexx);
  DefineCmd("FIND", find);
  DefineCmd("FIRST", first);
  DefineCmd("FIRSTTEXT", firstText);
  DefineCmd("FIRSTWINDOW", firstWindow);
  DefineCmd("FORCEAUTOSAVE", forceAutosave);
  DefineCmd("FREEMACRO", freeMacro);
  DefineCmd("GET", get);
  DefineCmd("GETASCII", getASCII);
  DefineCmd("GETBOOKMARK", getBookmark);
  DefineCmd("GOTOLINE", gotoLine);
  DefineCmd("GOTOBOOKMARK", gotoBookmark);
  DefineCmd("INFORMATION", information);
  DefineCmd("INSASCII", insASCII);
  DefineCmd("INSERT", insert);
  DefineCmd("INSERTFILE", insertFile);
  DefineCmd("ITEM", item);
  DefineCmd("LAST", last);
  DefineCmd("LASTCHANGE", lastChange);
  DefineCmd("LASTTEXT", lastText);
  DefineCmd("LASTWINDOW", lastWindow);
  DefineCmd("LEFT", left);
  DefineCmd("LINKCHANGES", linkChanges);
  DefineCmd("LINKCHANGESDONE", linkChangesDone);
  DefineCmd("MATCHBRACKET", matchBracket);
  DefineCmd("MENU", menu);
  DefineCmd("MOVE", move);
  DefineCmd("NEW", new);
  DefineCmd("NEWFOLD", newFold);
  DefineCmd("NEWWINDOW", newWindow);
  DefineCmd("NEXTTEXT", nextText);
  DefineCmd("NEXTWINDOW", nextWindow);
  DefineCmd("OPEN", open);
  DefineCmd("OPENALLFOLDS", openAllFolds);
  DefineCmd("OPENFOLD", openFold);
  DefineCmd("PAGEDOWN", pageDown);
  DefineCmd("PAGEUP", pageUp);
  DefineCmd("PASTE", paste);
  DefineCmd("PREVTEXT", prevText);
  DefineCmd("PREVWINDOW", prevWindow);
  DefineCmd("PRINT", print);
  DefineCmd("PRINTCLIP", printClip);
  DefineCmd("QUIT", quit);
  DefineCmd("READ", read);
  DefineCmd("REDO", redo);
  DefineCmd("REDRAW", redraw);
  DefineCmd("REPEATREXX", repeatRexx);
  DefineCmd("REPLACE", replace);
  DefineCmd("REQACTION", reqAction);
  DefineCmd("REQNUMBER", reqNumber);
  DefineCmd("REQOPTIONS", reqOptions);
  DefineCmd("REQCHOICE", reqChoice);
  DefineCmd("REQSTRING", reqString);
  DefineCmd("RESOLVEALLFOLDS", resolveAllFolds);
  DefineCmd("RESOLVEFOLD", resolveFold);
  DefineCmd("RIGHT", right);
  DefineCmd("SAVE", save);
  DefineCmd("SAVEAS", saveAs);
  DefineCmd("SAVECLIP", saveClip);
  DefineCmd("SAVEMACRO", saveMacro);
  DefineCmd("SAVESETTINGS", saveSettings);
  DefineCmd("SAVETEMP", saveTemp);
  DefineCmd("SCREENTOBACK", screenToBack);
  DefineCmd("SCREENTOFRONT", screenToFront);
  DefineCmd("SCROLLDX", scrollDX);
  DefineCmd("SCROLLDY", scrollDY);
  DefineCmd("SELECTTEXT", selectText);
  DefineCmd("SELECTWINDOW", selectWindow);
  DefineCmd("SET", set);
  DefineCmd("SETBOOKMARK", setBookmark);
  DefineCmd("SETKEY", setKey);
  DefineCmd("SETWINDOWBOX", setWindowBox);
  DefineCmd("SHIFTCLIP", shiftClip);
  DefineCmd("SUBITEM", subItem);
  DefineCmd("TITLE", title);
  DefineCmd("TOLOWER", toLower);
  DefineCmd("TOP", top);
  DefineCmd("TOUPPER", toUpper);
  DefineCmd("UNDO", undo);
  DefineCmd("UNMARK", unMark);
  DefineCmd("UP", up);
  DefineCmd("WINDOWTOBACK", windowToBack);
  DefineCmd("WINDOWTOFRONT", windowToFront);
  DefineCmd("WORDBEGIN", wordBegin);
  DefineCmd("WORDEND", wordEnd);
  DefineCmd("WORDLEFT", wordLeft);
  DefineCmd("WORDRIGHT", wordRight);

(* $IF M2Amiga THEN *)
  DefineCmd("COMPILE", compile);
  DefineCmd("EXECUTE", execute);
  DefineCmd("LINK", link);
  DefineCmd("MAKE", make);
  DefineCmd("FIRSTERROR", firstError);
  DefineCmd("GOTOERROR", gotoError);
  DefineCmd("LOADERRORS", loadErrors);
  DefineCmd("NEXTERROR", nextError);
  DefineCmd("PREVERROR", prevError);
(* $END *)

  (* variables: *)
  AVL.SInit(vars);
  DefineVar("AUTOINDENT", vAutoIndent);
  DefineVar("CHANGES", vChanges);
  DefineVar("CLEANLINES", vCleanLines);
  DefineVar("COLUMN", vColumn);
  DefineVar("FILENAME", vFilename);
  DefineVar("FINDSTR", vFindStr);
  DefineVar("ICONS", vIcons);
  DefineVar("INSERT", vInsert);
  DefineVar("LENGTH", vLength);
  DefineVar("LINE", vLine);
  DefineVar("LINEBEGIN", vLineBegin);
  DefineVar("LINEEND", vLineEnd);
  DefineVar("LINELEN", vLineLen);
  DefineVar("MARGIN", vMargin);
  DefineVar("MARK", vMark);
  DefineVar("MARKBEGIN", vMarkBegin);
  DefineVar("MARKEND", vMarkEnd);
  DefineVar("NAME", vName);
  DefineVar("PATH", vPath);
  DefineVar("POSITION", vPosition);
  DefineVar("RECORDING", vRecording);
  DefineVar("REPLACESTR", vReplaceStr);
  DefineVar("SCREENHEIGHT", vScreenHeight);
  DefineVar("SCREENWIDTH", vScreenWidth);
  DefineVar("SIZE", vSize);
  DefineVar("TEXTID", vTextID);
  DefineVar("TEXTS", vTexts);
  DefineVar("WINDOWCOLS", vWindowCols);
  DefineVar("WINDOWHEIGHT", vWindowHeight);
  DefineVar("WINDOWID", vWindowID);
  DefineVar("WINDOWLEFT", vWindowLeft);
  DefineVar("WINDOWLINES", vWindowLines);
  DefineVar("WINDOWS", vWindows);
  DefineVar("WINDOWTOP", vWindowTop);
  DefineVar("WINDOWWIDTH", vWindowWidth);
  DefineVar("WORDWRAP", vWordWrap);

  (* keys: *)
  AVL.SInit(keys);
  DefineKey("ALT", kAlt);
  DefineKey("AMIGA", kAmiga);
  DefineKey("BACKSPACE", kBackspace);
  DefineKey("CTRL", kCtrl);
  DefineKey("DEL", kDel);
  DefineKey("DOWN", kDown);
  DefineKey("ENTER", kEnter);
  DefineKey("ESC", kEsc);
  DefineKey("F1", kF1);
  DefineKey("F2", kF2);
  DefineKey("F3", kF3);
  DefineKey("F4", kF4);
  DefineKey("F5", kF5);
  DefineKey("F6", kF6);
  DefineKey("F7", kF7);
  DefineKey("F8", kF8);
  DefineKey("F9", kF9);
  DefineKey("F10", kF10);
  DefineKey("HELP", kHelp);
  DefineKey("LEFT", kLeft);
  DefineKey("NUMPAD", kNumPad);
  DefineKey("RETURN", kReturn);
  DefineKey("RIGHT", kRight);
  DefineKey("SHIFT", kShift);
  DefineKey("SPACE", kSpace);
  DefineKey("TAB", kTab);
  DefineKey("UP", kUp);

  msgCnt:= 0;
  missingArgs:= FALSE;

CLOSE
  IF stdio # NIL THEN
    WHILE ~Dos.Close(stdio) DO Dos.Delay(25) END;
  END;
END ERexx.